.TITLE	SSTSR
	.IDENT	/12.02/
;
; Copyright (c) 1995 by Mentec, Inc., U.S.A.
; All rights reserved
;
;
; MODIFIED FOR RSX-11M-PLUS VERSION 3.0 BY:
;
;	B. S. MCCARTHY
;
; MODIFIED FOR RSX-11M-PLUS VERSION 4.0 BY:
;
;	B. S. MCCARTHY		22-DEC-86		12.00
;
;		BM377 -- MOVE DRDSP TO DIR11M
;
;	J. W. BERZLE		7-MAY-87		12.01
;
;		JWB212 -- CORRECT TEST OF STACK DEPTH
;
;	D. Carroll		18-Oct-1995		12.02
;		DC404 - Include PSECT statement to allow sysgen to
;			fully expand ICB pool ...
;
; MACRO LIBRARY CALLS
;

	.MCALL	ABODF$,HDRDF$,HWDDF$,PKTDF$,BGCK$A,BGCK$R,BCKDF$
	BCKDF$			;DEFINE THE BUGCHECK CODES
	ABODF$			;DEFINE TASK ABORT CODES
	HDRDF$			;DEFINE TASK HEADER OFFSETS
	HWDDF$			;DEFINE HARDWARE REGISTERS
	PKTDF$			;DEFINE I/O PACKET OFFSETS

;
; LOCAL DATA
;
; FLOATING POINT EXCEPTION VECTOR (FINAL SETUP OF THIS VECTOR AND, IF
; NECESSARY, THE PIRQ VECTOR IS PERFORMED IN INITL AND THE MCR SAVE
; COMMAND.)
;


	.IF DF	F$$LPP!F$$LTP

	.ASECT
.=244
	.WORD	$FLTRP		;
	.WORD	PR7		;

	.PSECT

	.ENDC


;
; SEGMENT FAULT VECTOR
;

	.ASECT
.=250
	.WORD	$SGFLT		;
	.WORD	PR7		;
	.PSECT									;DC404
										;DC404
	.IIF	DF,K$$DAS&I$$CBP,	.PSECT	EXEC1				;DC404
										;**-1
;+
;
; **-$EMSST-NON RSX EMT/TRAP INSTRUCTION
;
; THIS ROUTINE IS TRANSFERED TO BY THE DIRECTIVE DISPATCHER WHEN A NON RSX
; EMT OR A TRAP INSTRUCTION IS EXECUTED. THE MACHINE STATE HAS ALREADY BEEN
; SAVED. THE EMT/TRAP CODE (LOW BYTE OF INSTRUCTION) IS SETUP TO BE
; PASSED TO THE USER AND CONTROL IS TRANSFERED TO THE SST EXIT ROUTINE.
;
; INPUTS:
;
;	R5=ADDRESS OF THE EMT/TRAP INSTRUCTION.
;
; OUTPUTS:
;
;	04(SP)=EMT/TRAP CODE MULTIPLIED BY 2.
;	02(SP)=SST CODE (SCEMT=EMT, SCTRP=TRAP).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO USER STACK (6).
;-

	.ENABL	LSB
$EMSST::MOV	(SP),R5		;GET EMT/TRAP INSTRUCTION
	BIC	#177400,(SP)	;CLEAR INSTRUCTION CODE
	ASL	(SP)		;MULTIPLY CODE BY 2
	MOV	#S.CEMT,-(SP)	;ASSUME NON-RSX EMT INSTRUCTION
	BIT	#400,R5		;EMT INSTRUCTION?
	BEQ	10$		;IF EQ YES-SET NUMBER OF BYTES
	MOV	#S.CTRP,(SP)	;SET FOR TRAP INSTRUCTION
10$:	MOV	#3*2,-(SP)	;SET NUMBER OF BYTES
	JMP	SSTXT		;TAKE COMMON SST EXIT ROUTINE

;+
; **-$FLTRP-FLOATING POINT EXCEPTION (11/40)
;
; THIS ROUTINE IS TRAPPED TO WHEN AN 11/40 FLOATING POINT EXCEPTION FAULT
; OCCURS. THE CURRENT MACHINE STATE IS SAVED AND CONTROL IS TRANSFERED TO
; THE SST EXIT ROUTINE.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	02(SP)=SST CODE (SCFLT).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO USER STACK (4).
;-

$FLTRP::			;DEFINE UNCONDITIONALLY FOR VECTOR SETUP


	.IF DF	F$$LTP

	DIRSV$			;;;SAVE REGISTERS AND CLEAR PRIORITY
	MOV	#S.CFLT,-(SP)	;SET FOR FLOATING POINT EXCEPTION FAULT
	MOV	#BE.FLT,R3	;FLOATING POINT EXCEPTION BUGCHECK CODE
	BR	20$		;SET NUMBER OF BYTES

	.ENDC


;+
; **-$FPPR7-$FPPR8-$FPPRQ-FLOATING POINT PROCESSOR EXCEPTION HANDLING
;
; THESE ROUTINES HANDLE EXCEPTION FAULTS FROM THE FLOATING POINT
; PROCESSOR.  THE FLOATING POINT EXCEPTION AND ADDRESS REGISTERS AND
; THE CURRENT TASK TCB ARE SAVED AND THEN AN ATTEMPT IS MADE TO QUEUE AN
; AST TO THE TASK AT FORK LEVEL.  THESE ROUTINES SUPPORT TWO MODES OF
; OPERATION DEPENDING ON WHETHER THE FPP'S EXCEPTION FAULTS CAN OCCUR
; WHILE THE PROCESSOR IS AT PRIORITY 7 OR NOT.  IF THE FPP'S EXCEPTION
; FAULT CAN OCCUR WHILE THE PROCESSOR IS AT PRIORITY 7, THEN THE
; PROCESSOR MUST HAVE A PIRQ REGISTER.  INITL AND THE MCR SAVE
; COMMAND DETERMINE WHICH MODE OF OPERATION IS TO BE USED OR NOT
; DEPENDING ON WHETHER THE PROCESSOR HAS A PROGRAM INTERRUPT REQUEST
; REGISTER (PIRQ) OR NOT, AND SET UP THE FPP AND PIRQ VECTORS
; ACCORDINGLY.  THE ROUTINES OPERATE AS FOLLOWS.
;
;    1.	IF THE PROCESSOR DOES NOT HAVE A PIRQ REGISTER THEN THE FPP MUST
;	NEVER FAULT WHEN THE PROCESSOR IS AT PRIORITY 7 OR IT MUST BE
;	SYNCHRONOUS.  IN THIS CASE THE FLOATING POINT EXCEPTION VECTOR
;	POINTS TO $FPPR7, AND THE PROCESSOR SIMPLY CALLS INTERRUPT SAVE
;	AND FORK TO GET TO SYSTEM STATE.
;
;    2.	IF THE PROCESSOR HAS A PIRQ REGISTER, THE FLOATING POINT EXCEP-
;	TION TRAP VECTOR POINTS TO $FPPR8 AND THE PIRQ VECTOR POINTS TO
;	$FPPRQ.  FLOATING POINT TRAPS ARE CONVERTED TO PIRQ PRIORITY 1
;	INTERRUPTS AFTER SAVING THE FLOATING POINT STATUS.  ON THE PIRQ
;	TRAP AN INT SAVE AND FORK IS USED TO GET TO SYSTEM STATE.  NOTE
;	THAT THIS STRATEGY WOULD ALSO WORK FOR PROCESSORS DESCRIBED IN 1
;	ABOVE.
;
; INPUTS:
;
;	THE FLOATING POINT EXCEPTION REGISTER CONTAINS THE REASON FOR THE
;	FAULT AND THE FLOATING POINT ADDRESS REGISTER CONTAINS THE ADDRESS
;	OF THE FAULTING INSTRUCTION.
;
; OUTPUTS:
;
;	AN ATTEMPT IS MADE TO QUEUE AN AST TO THE TASK CAUSING THE FAULT
;	WITH THE CONTENTS OF THE FLOATING POINT EXCEPTION REGISTER AND
;	AND ADDRESS REGISTER.
;-


	.IF DF	F$$LPP

$FPPR7::STST	$FLSTS		;;;STORE FLOATING POINT EXCEP AND ADDR
	BR	14$		;;;

$FPPR8::STST	$FLSTS		;;;STORE FLOATING POINT EXCEP AND ADDR
	BIS	#<2*256.>,PIRQ	;;;POST PROGRAMMED INTERRUPT REQUEST
	RTI			;;;WAIT FOR PIRQ INTERRUPT

$FPPRQ::CLR	PIRQ		;;;DISABLE PROGRAM INTERRUPT REQUEST
14$:	MOV	$TKTCB,$FLTCB	;;;MUST SAVE FAULTING TCB NOW
	CALL	$INTSV,PR1	;;;GO TO PRIORITY 1
	MOV	$FLFRK,R4	;;;SET ADDRESS OF FORK BLOCK
	CALL	$FORK0		;;;CREATE A SYSTEM PROCESS
	MOV	#AS.FPA,R4	;GET CODE FOR FLOATING POINT AST
	MOV	$FLTCB,R5	;GET TCB ADDRESS OF FAULTING TASK
	CALL	$DASTT		;DECLARE FLOATING POINT AST
	BCS	15$		;IF CS NO AST DECLARED
	MOV	$FLSTS,A.PRM+2(R1) ;INSERT AST PARAMETERS
	MOV	$FLSTS+2,A.PRM(R1) ;
15$:	RETURN			;

	.IFF

$FPPR7::			;REFERENCE LABEL FOR SAVE
$FPPR8::			;REFERENCE LABEL
$FPPRQ::			;REFERENCE LABEL

	.ENDC


;+
; **-$ILINS-ILLEGAL OR RESERVED INSTRUCTION
;
; THIS ROUTINE IS TRAPPED TO WHEN AN ILLEGAL OR RESERVED INSTRUCTION
; IS EXECUTED. THE CURRENT MACHINE STATE IS SAVED AND CONTROL IS TRANS-
; FERRED TO THE SST EXIT ROUTINE.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	02(SP)=SST CODE (SCILI).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO THE USER STACK (4).
;
; THIS ROUTINE IS ALSO ENTERED WHEN THE CSM INSTRUCTION IS EXECUTED
; ON A PROCESSOR THAT DOES NOT SUPPORT CSM. IT WILL FIELD THE ILLEGAL
; INSTRUCTION TRAP AND EMULATE THE CSM INSTRUCTION.
;
; NOTE:	ONLY ONE FORM OF THE CSM INSTRUCTION IS SUPPORTED.
;
;	MOV	#<ADDRESS OF SUPER ROUTINE>,-(SP)
;	CSM	(SP)+
;
; KERNEL STACK ON ENTRY.
;
;	0(SP) = TRAP PC + 2
;	2(SP) = PS PRIOR TO TRAP
;
; KERNEL STACK IMMEDIATELY BEFORE RTI INSTRUCTION.
;
;	0(SP) = (10) (VIRTUAL ADDRESS IN SUPERVISOR MODE)
;	2(SP) = PS WITH PROPER PREVIOUS AND CURRENT MODE SUPER
;
; SUPER STACK IMMEDIATELY BEFORE RTI INSTRUCTION.
;
;	0(SP) = ADDRESS OF SUPERVISOR MODE ROUTINE
;	2(SP) = RETURN ADDRESS
;	4(SP) = PS PRIOR TO TRAP
;
;-


$ILINS::			;;;REF LABEL


	.IF DF	S$$LIB


	.IF NDF	X$$DBT

	TST	$STKDP		;;;PREVIOUS MODE USER ?
	BLE	17$		;;;IF LE NO

	.ENDC	;NDF X$$DBT


	MOV	(SP),-(SP)	;;;COPY TRAP PC + 2
	SUB	#2,(SP)		;;;CALCULATE TRAP PC
	MFPI	@(SP)+		;;;PICK UP TRAP INSTRUCTION
	CMP	(SP),#7027	;;;IS IT CSM #N ?
	BEQ	155$		;;;IF EQ YES
	CMP	(SP),#7026	;;;IS IT CSM (SP)+
	BNE	165$		;;;IF NE NO - ILLEGAL INSTRUCTION TRAP
155$:	TSTB	$SUPFL		;;;TASK MAPPED TO SUPER WINDOWS ?
	BEQ	165$		;;;IF EQ NO - ILLEGAL INSTRUCTION TRAP
	BIT	#10,SR3		;;;IS THE INSTRUCTION LEGAL ON THIS MACHINE?
	BNE	165$		;;;IF NE NO - ILLEGAL INSTRUCTION TRAP
	ADD	#170751,(SP)	;;;IS IT CSM #N ? (THIS INSTRUCTION WILL
				;;;SET C FOR #N, BUT NOT (SP)+, AND WILL
				;;;LEAVE A ZERO CONSTANT (USED LATER FOR
				;;;STACK ADJUSTMENT) ON THE STACK
	MOV	R0,-(SP)	;;;SAVE R0
	BCS	156$		;;;IF CS WE DETERMINED 2 INST AGO THIS
				;;;WAS CSM (SP)+
	MOV	#2,2(SP)	;;;IT WAS CSM (SP)+ - SET CONSTANT TO
				;;;ADD TO USER STACK FOR ADJUSTING BELOW
	MFPI	SP		;;;GET PREVIOUS MODE STACK POINTER
$DSLM1::MFPD$	@(SP)+		;;;GET ADDR OF SUPER MODE ROUTINE
	BR	157$		;;;FINISH IN COMMON CODE
156$:	MOV	4(SP),-(SP)	;;;GET ADDRESS OF SECOND HALF OF INSTRUCTION
	MFPI	@(SP)+		;;;GET IMMEDIATE OPERAND
157$:	MOV	SP,R0		;;;COPY KERNEL STACK POINTER
	ADD	#6,R0		;;;POINT TO TRAP PC
	MOV	(R0)+,-(SP)	;;;PUSH PC OF CALLER
	MOV	(R0),-(SP)	;;;PUSH PS OF CALLER
	MOV	#CSMODE!PMODE,(R0) ;;; CURRENT=SUPER, PREVIOUS=USER
	BIC	#17,(SP)	;;;CLEAR STACKED CONDITION CODES
	BMI	16$		;;;IF MI PREVIOUS MODE WAS USER
	BIC	#^CPSMODE&PMODE,(R0) ;;;SET PREVIOUS MODE TO SUPER
16$:	MFPI	SP		;;;GET PREVIOUS MODE SP
	ADD	12(SP),(SP)	;;;ADJUST FOR STACK DIFFERENCE BETWEEN
				;;;(SP)+ AND #N VARIATION
	MOV	(SP),R0		;;;COPY IT
	SUB	#6,(SP)		;;;ADJUST SP FOR PUSHED PS,PC,SUPER ROUTINE
	BIC	#^CPSMODE&PMODE,PS ;;;SET PREVIOUS MODE TO SUPER
	MTPI	SP		;;;SET SUPER SP
	MTPD	-(R0)		;;;PUSH PS ON USER STACK
	MTPD	-(R0)		;;;PUSH PC ON SUPER STACK
	MTPD	-(R0)		;;;PUSH ADDRESS OF SUPER ROUTINE
	MOV	(SP)+,R0	;;;RESTORE R0
	CMP	(SP)+,(SP)+	;;;POINT TO TRAP PS
$DSLM2::MFPI	10		;;;SET RETURN PC IN SUPER MODE FROM SUPER 10
	RTI			;;;RETURN TO (SUPER VIRTUAL 10)

165$:	TST	(SP)+		;;;POP CSM INSTRUCTION FROM STACK

	.ENDC	;DF S$$LIB


17$:	DIRSV$			;;;SAVE REGISTERS

	MOV	#S.CILI,-(SP)	;SET FOR ILLEGAL OR RESERVED INSTRUCTION
	MOV	#BE.ILI,R3	;ILLEGAL INSTRUCTION BUGCHECK CODE
	BR	20$		;SET NUMBER OF BYTES
	.PAGE
;+
; **-$IOTRP-IOT INSTRUCTION
;
; THIS ROUTINE IS TRAPPED TO WHEN AN IOT INSTRUCTION IS EXECUTED. IF THE
; STACK DEPTH IS NOT +1, THEN THE SYSTEM IS CRASHED VIA A JUMP TO
; $CRASH. ELSE THE CURRENT MACHINE STATE IS SAVED AND CONTROL IS TRANS-
; FERED TO THE SST EXIT ROUTINE.
;
; IF THE CURRENT TASK HAS FAST MAPPING ENABLED ($FMAPP>0) THEN THE
; FAST MAP DESCRIPTOR IN THE REGISTERS IS USED TO REMAP A PLAS WINDOW.
; (SEE DRMAP, WHERE THE REMAPPING ACTUALLY TAKES PLACE)
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	IF THE CURRENT STACK DEPTH IS NOT +1, THEN THE SYSTEM IS CRASHED.
;	ELSE THE FOLLOWING ARGUMENTS ARE SETUP ON THE CURRENT STACK:
;
;	02(SP)=SST CODE (SCIOT).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERRED TO THE USER STACK (4).
;-
;
; NOTES:
;
; REGISTER CONTENTS ON ENTRY/EXIT TO FAST MAP ARE DEFINED IN DRMAP.
	.PAGE
18$:	BGCK$A	BF.EXE,BE.IOT,INTERNAL ;;;SETUP ERROR CODES FOR IOT
				       ;;;IN SYSTEM STATE
	JMP	$CREMT		;;;GO CRASH THE SYSTEM

$IOTRP::TST	$STKDP		;;;RUNNING ON SYSTEM STACK?
	BLE	18$		;;;IF LE NO, SYSTEM FAULT

	.IF DF F$$MAP&X$$HDR&P$$LAS

	TST	$FMAPP		;;;FAST MAP IN USE FOR THIS TASK?
	BEQ	189$		;;;IF EQ NO

	.IF DF	D$$PAR

	MOV	$DRAP3,KINAR5	;;;MAP TO PLAS DIRECTIVE COMMON

	.ENDC	; DF D$$PAR

	JMP	$DRFMP		;;;GO EXECUTE FAST MAP DIRECTIVE

189$:				;;;REFERENCE LABEL

	.ENDC ; DF F$$MAP&X$$HDR&P$$LAS

	DIRSV$			;;;SAVE REGISTERS AND SET PRIORITY
	MOV	#S.CIOT,-(SP)	;SET FOR IOT INSTRUCTION
	BR	20$		;SET NUMBER OF BYTES

;+
; **-$SGFLT-SEGMENT FAULT
;
; THIS ROUTINE IS TRAPPED TO WHEN A SEGMENT FAULT OCCURS. THE CURRENT
; MACHINE STATE IS SAVED, SR0 THRU SR2 ARE SETUP TO BE PASSED TO THE USER,
; AND CONTROL IS TRANSFERED TO THE SST EXIT ROUTINE.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	10(SP)=CONTENTS OF SR0.
;	06(SP)=CONTENTS OF SR2.
;	04(SP)=CONTENTS OF SR1.
;	02(SP)=SST CODE (SCSGF).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO THE USER STACK (10).
;-

$SGFLT::DIRSV$			;;;SAVE REGISTERS AND SET PRIORITY
	MOV	#SR0+4,R5	;POINT SR2
	MOV	(R5),-(SP)	;SAVE SR2
	MOV	(SP),-(SP)	;COPY SAVED SR2
	MOV	-(R5),-(SP)	;SAVE SR1
	MOV	-(R5),4(SP)	;SAVE SR0
	BIC	#160000,(R5)	;UNFREEZE MEMORY MANAGEMENT UNIT
	MOV	#S.CSGF,-(SP)	;SET FOR SEGMENT FAULT
	MOV	#5*2,-(SP)	;SET NUMBER OF BYTES
	MOV	#BE.SGF,R3	;SEGMENT FAULT BUGCHECK CODE
	BR	SSTXT		;TAKE COMMON SST EXIT ROUTINE

;+
; **-$TRACE-TRACE (T-BIT) OR BREAK POINT INSTRUCTION (BPT) TRAP
;
; THIS ROUTINE IS TRAPPED TO WHEN A TRACE TRAP (T-BIT) OCCURS OR A BREAK-
; POINT TRAP INSTRUCTION IS EXECUTED. THE CURRENT MACHINE STATE IS SAVED
; AND CONTROL IS TRANSFERED TO THE SST EXIT ROUTINE.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	02(SP)=SST CODE (SCBPT).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO THE USER STACK (4).
;-

$TRACE::DIRSV$			;;;SAVE REGISTERS AND SET PRIORITY
	MOV	#S.CBPT,-(SP)	;SET FOR TRACE OR BREAKPOINT TRAP
	MOV	#BE.BPT,R3	;TRACE OR BREAKPOINT BUGCHECK CODE
	BR	20$		;SET NUMBER OF BYTES

;+
; **-$TRP04-TRAPS AT 4 (ODD ADDRESS, NONEX MEM, ETC.)
;
; THIS ROUTINE IS TRAPPED TO WHEN A TRAP AT 4 OCCURS. IF A STACK VIOLATION
; HAS CAUSED THE TRAP (I.E. A STACKPOINTER OF LESS THAN 400), THEN THE
; THE SYSTEM IS CRASHED. ELSE THE CURRENT MACHINE STATE IS SAVED AND
; CONTROL IS TRANSFERED TO THE SST EXIT ROUTINE.
;
; INPUTS:
;
;	NONE.
;
; OUTPUTS:
;
;	02(SP)=SST CODE (SCOAD).
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO THE USER STACK (4).
;-

$TRP04::CMP	SP,#400		;;;STACK VIOLATION?
	BLO	30$		;;;IF LO YES
	DIRSV$			;;;SAVE REGISTERS AND SET PRIORITY
	CLR	-(SP)		;SET FOR ODD ADDRESS TRAP
	MOV	#BE.ODD,R3	;ODD ADDRESS OR OTHER TRAP 4 BUGCHECK CODE
20$:	MOV	#2*2,-(SP)	;SET NUMBER OF BYTES
	BR	SSTXT		;TAKE COMMON SST EXIT ROUTINE
30$:	BGCK$A	BF.EXE,BE.STK,DIRECT ;;;SETTUP THE ERROR CODES FOR A
				;;;STACK OVERFLOW
	.DSABL	LSB

;+
; **-SSTXT-COMMON SST EXIT ROUTINE
;
; CONTROL IS TRANSFERED TO THIS ROUTINE TO EFFECT AN SST. IF THE CURRENT
; STACK DEPTH IS NOT ZERO, THEN THE SYSTEM IS CRASHED. ELSE AN ATTEMPT IS
; MADE TO EFFECT AN SST FOR THE CURRENT TASK. IF THE TASK DOES NOT HAVE
; AN APPROPRIATE SST VECTOR ENTRY OR A PUSH OF THE SST PARAMETERS ONTO THE
; TASK STACK CANNOT BE EFFECTED, THEN THE TASK IS ABORTED. ELSE THE SST
; IS SETUP AND A DIRECTIVE EXIT IS EXECUTED.
;
; INPUTS:  (MAPPED SYSTEM)
;
;	24(SP)=PS WORD SAVED BY SST TRAP.
;	22(SP)=PC WORD SAVED BY SST TRAP.
;	20(SP)=SAVED R5.
;	16(SP)=SAVED R4.
;	14(SP)=SAVED R3.
;	12(SP)=SAVED R2.
;	10(SP)=SAVED R1.
;	06(SP)=SAVED R0.
;	04(SP)=SST PARAMETER (ZERO OR MORE PARAMETERS MAY BE SPECIFIED).
;	02(SP)=SST CODE.
;	00(SP)=NUMBER OF BYTES TO BE TRANSFERED TO USER STACK.
;
;	R3 - BUGCHECK ERROR CODE
;
; OUTPUTS:
;
;	AN ATTEMPT IS MADE TO EFFECT THE SPECIFIED SST FOR THE CURRENT TASK.
;-

	.ENABL	LSB

SSTXT:	MOV	$SAHPT,R5	;GET ADDRESS OF TASK HEADER
	CMP	#-1,$STKDP	;FAULT OCCUR AT STACK DEPTH ZERO?
	BNE	7$		;IF NE NO
	MOV	SP,R1		;COPY CURRENT STACK POINTER
	ADD	(SP),R1		;ADD NUMBER OF BYTES TO BE TRANSFERRED
	MOV	16(R1),R0	;GET FAULT PC ADDRESS
	CMP	R0,#$DRLM1	;FAULT OCCUR IN DIRECTIVE DISPATCHER?
	BLO	3$		;IF LO NO
	CMP	R0,#$DRLM2	;FAULT OCCUR IN DIRECTIVE DISPATCHER?
	BHI	3$		;IF HI NO

	.IF DF	D$$PAR

	CMP	KINAR5,$DRAPR	;YES, BUT DID THE FAULT OCCUR IN
				;THE DIRECTIVE DISPATCHER? (IS THE
				;FIRST DIRECTIVE COMMON MAPPED?)
	BNE	3$		;IF NE NO

	.ENDC	; DF D$$PAR

	JMP	90$		;YES
3$:
	.IF DF	D$$PAR

	CMP	KINAR5,$DRAP2	;2ND DIRECTIVE COMMON MAPPED ?
	BNE	7$		;IF NE NO, CAN'T HAVE BEEN IN DRQIO

	.ENDC	; DF D$$PAR

	CMP	R0,#$DQLM1	;TRAP OCCUR IN QIO DIRECTIVE ?
	BLO	7$		;IF LO NO
	CMP	R0,#$DQLM2	;FAULT OCCUR IN QIO DIRECTIVE?
	BLOS	90$		;IF LOS YES
7$:	TST	$STKDP		;STACK DEPTH ZERO?
	BNE	60$		;IF NE NO - FATAL SYSTEM ERROR


	.IF DF	S$$LIB

	MOV	SP,R1		;COPY CURRENT STACK POINTER
	ADD	(SP),R1		;ADD NUMBER OF BYTES TO BE TRANSFERED
	MOV	16(R1),R0	;GET FAULT PC ADDRESS
	CMP	R0,#$DSLM1	;FAULT OCCUR IN CSM INSTRUCTION EMULATE?
	BLO	8$		;IF LO NO
	CMP	R0,#$DSLM2	;FAULT OCCUR IN CSM INSTRUCTION EMULATE?
	BHI	8$		;IF HI NO
	BIT	#PMODE,PS	;PREVIOUS MODE KERNEL ?
	BEQ	100$		;IF EQ YES, - EXCEPTION IN CSM EMULATOR
8$:				;REFERENCE LABEL

	.ENDC	;DF S$$LIB





	.IF DF	P$$D70

	CLR	@$CPUER		;CLEAR CPU ERROR REGISTER

	.IF NDF	M$$EXT

	NOP			;THIS NOP MUST BE HERE.
				;UNLESS THE MICRO CODE BUG IN THE
				;11/60 IS FIXED (ECO M7872-00007),
				;CLEARING THE CPU ERROR REGISTER
				;WILL CAUSE THIS WORD TO BE SKIPPED.

	.ENDC


	.ENDC


	CLR	$TEMP0		;INDICATE USE NORMAL ABORT CODE

$CNBPT::			;ENTRY POINT FROM BOM$ DIRECTIVE


	MOV	R5,R4		;COPY ADDRESS OF HEADER
	ADD	#H.ODVA,R4	;POINT TO ODT SST VECTOR DESCRIPTOR
	MFPI	SP		;GET CURRENT TASK STACK POINTER
	CALL	10$		;SST ADDRESS IN ODT VECTOR?
	MOV	#80$,-(SP)	;SST ADDRESS IN TASK VECTOR?
10$:	MOV	$SAHDB,KISAR6	;MAP CURRENT TASK HEADER
	MOV	(R4)+,R3	;GET ADDRESS OF SST VECTOR
	BEQ	20$		;IF EQ NO VECTOR THIS DESCRIPTOR


	.IF DF	S$$LIB

	BIS	#PMODE,PS	;ASSUME SST HANDLED IN USER STATE
	BIT	#1,R3		;AST HANDLED IN SUPERVISOR STATE?
	BEQ	15$		;IF EQ NO
	BIC	#^CPSMODE&PMODE,PS ;SET PREVIOUS MODE TO SUPERVISOR
	DEC	R3		;REMOVE SUPERVISOR MODE FLAG

	.ENDC


15$:	CMP	6(SP),(R4)	;VECTOR LONG ENOUGH TO COVER SST
	BHIS	20$		;IF HIS NO
	MOV	R3,R0		;COPY VECTOR ADDRESS
	MOV	#2,R1		;TWO BYTE SIZE FOR ADDRESS CHECK
	ADD	6(SP),R3	;POINT TO APPROPRIATE VECTOR ENTRY
	CALL	$ACHRO		;CHECK FOR READ ONLY ACCESS
	BCS	20$		;IF CS VECTOR ELEMENT IS INVALID
	MFPD$	(R3)		;GET ADDRESS OF SST ROUTINE
	MOV	(SP)+,R3	;
	BNE	30$		;IF NE SST ROUTINE FOUND
20$:	TST	(R4)+		;POINT TO NEXT VECTOR DESCRIPTOR
	RETURN			;
30$:	TST	(SP)+		;REMOVE RETURN ADDRESS
	MOV	2(SP),R1	;GET NUMBER OF BYTES TO BE TRANSFERED
	SUB	R1,(SP)		;CALCULATE NEW TOP OF STACK
	MOV	(SP),R0		;COPY NEW TOP OF STACK ADDRESS
	MTPI	SP		;RESTORE NEW TASK STACK POINTER
	CALL	$ACHCK		;ADDRESS CHECK PUSH ONTO TASK STACK
	BCS	70$		;IF CS ADDRESS CHECK FAILURE

	.IF DF	X$$HDR

	MOV	-(R4),$TEMP0	;SAVE SST ADDRESS FROM TASK HEADER

	.ENDC	; DF X$$HDR

	CALL	$RELOM		;RELOCATE AND MAP STACK ADDRESS
	MOV	(SP)+,R1	;GET NUMBER OF BYTES TO TRANSFER
	CMP	-(R1),-(R1)	;ADJUST BY 4 BYTES (PS AND PC WORDS)
	ASR	R1		;CONVERT TO WORD COUNT
	TST	(SP)+		;REMOVE SST CODE FROM STACK
40$:	DEC	R1		;ANY MORE PARAMETERS TO TRANSFER?
	BLT	50$		;IF LT NO
	MOV	(SP)+,(R0)+	;TRANSFER PARAMETER TO TASK STACK
	BR	40$		;
50$:	MOV	#$UMPC,R1	;POINT TO SAVED PC WORD
	MOV	(R1),(R0)+	;SAVE PC AT TRAP ON USER STACK
	MOV	R3,(R1)+	;SET SST PC WORD
	MOV	(R1),(R0)	;SAVE PS AT TRAP ON USER STACK
	MOV	#CMODE!PMODE,(R1) ;SET SST PS WORD


	.IF DF	S$$LIB


	.IF DF	X$$HDR

	BIT	#1,$TEMP0	;SUPERVISOR MODE SST ROUTINE ?

	.IFF	; DF X$$HDR

	BIT	#1,-(R4)	;SUPERVISOR MODE SST ROUTINE ?

	.ENDC	; DF X$$HDR

	BEQ	55$		;IF EQ NO
	TSTB	$SUPFL		;LINKED TO SUPER MODE LIBRARY
	BEQ	55$		;IF EQ NO, FORCE USER MODE
	BIC	#^CCSMODE&CMODE,(R1) ;SET RETURN PS WORD TO SUPER MODE
	TST	(R0)		;WAS PREVIOUS MODE SUPERVISOR?
	BMI	54$		;IF MI NO
	BIC	#^CPSMODE&PMODE,(R1) ;SET PREVIOUS MODE TO SUPERVISOR
54$:				;REFERENCE LABEL

	.ENDC


55$:	RETURN			;EXIT FROM TRAP

;
; SST FAULT AT NON ZERO STACK DEPTH-FATAL SYSTEM ERROR
;

60$:	BGCK$R	#BF.EXE,R3,FATAL;BUGCHECK THE SYSTEM
				;FACILITY IS GENERAL EXEC ERROR.
				;THE ERROR CODE IS FOR THE
				;SST CAUSING THE PROBLEM.

;
; SST CANNOT BE EFFECTED BECAUSE OF BAD TASK STACK
;

70$:	MOV	#S.CSST,R0	;SET BAD STACK SST ABORT CODE
	BR	81$		;ABORT TASK

;
; SST CANNOT BE EFFECTED BECAUSE OF NO SST VECTOR ENTRY
;

80$:	MOV	4(SP),R0	;SET SST ABORT CODE
	TST	$TEMP0		;IS THERE A BOM$ ABORT CODE?
	BEQ	81$		;IF EQ NO, OK AS IS
	MOV	$TEMP0,R0	;USE BOM$ ERROR CODE INSTEAD
81$:	MOV	#$STACK-22,SP	;RELOAD EXEC STACK POINTER
85$:	CALLR	$ABCTK		;ABORT CURRENT TASK

;
; FAULT FROM PROTECTED LIMITS IN DRDSP OR DRQIO
;

90$:


	.IF DF	P$$D70

	CLR	@$CPUER		;CLEAR CPU ERROR REGISTER

	.IF NDF	M$$EXT

	NOP			;THIS NOP MUST BE HERE.
				;UNLESS THE MICRO CODE BUG IN THE
				;11/60 IS FIXED (ECO M7872-00007),
				;CLEARING THE CPU ERROR REGISTER
				;WILL CAUSE THIS WORD TO BE SKIPPED.

	.ENDC

	.ENDC


	INC	$STKDP		;CORRECT STACK DEPTH INDICATOR
	MOV	20(R1),PS	;RESTORE CORRECT PREVIOUS MODE
	DRSTS	D.RS98		;SET DIRECTIVE STATUS


;
; FAULT FROM PROTECTED LIMITS IN CSM INSTRUCTION EMULATION
;
;	AT THIS POINT THE STACK IS AS FOLLOWS
;
;	 0(SP) - NUMBER OF BYTES TO BE TRANSFERRED
;			.
;		 SST PARAMETERS
;			.
;	   0(R1) - RETURN POINTER TO $DIRXT
;	   2(R1) - SAVED R0 FROM TRAP
;	   4(R1) - SAVED R1
;	   6(R1) - SAVED R2
;	  10(R1) - SAVED R3
;	  12(R1) - SAVED R4
;	  14(R1) - SAVED R5
;	  16(R1) - SAVED PC
;	  20(R1) - SAVED PS
;			.
;	$STACK-6 - SAVED R0 DURING CSM EMULATION
;	$STACK-4 - PC OF CSM TRAP
;	$STACK-2 - PS OF CSM TRAP
;
;	WE WILL CLEAN UP THE STACK AND MAKE IT LOOK AS IF WE
;	ENTERED THROUGH $DIRSV

	.IF DF	S$$LIB

100$:
	MTPS	#PR7		;DISABLE INTERRUPTS
	MOV	14(R1),R5	;;;RESTORE R5 FROM $DIRSV
	MOV	#$STACK-6,SP	;;;TRUNCATE STACK
	MOV	(SP),R0		;;;GET SAVED R0 VALUE
	MOV	R5,(SP)		;;;SAVE R5
	MOV	20(R1),R5	;;;AND GET OLD PS
	BIC	#^C<PMODE>,R5	;;;CLEAR ALL BUT PREVOIUS MODE BITS
	BIS	R5,PS		;;;SET PREVIOUS MODE TO CORRECT
	MOV	R4,-(SP)	;;;SAVE R4
	MOV	SP,@$HEADR	;;;SAVE STACK POINTER IN HEADER
	MOV	4(R1),R1	;;;RESTORE ORIGINAL VALUE OF R1
	MTPS	#0		;;;ALLOW INTERRUPTS
	MOV	R3,-(SP)	;SAVE REST OF REGISTERS
	MOV	R2,-(SP)	;TO MAKE IT LOOK
	MOV	R1,-(SP)	;LIKE A NORMAL SST
	MOV	R0,-(SP)	;ENTRY TO THE
	MOV	#$DIRXT,-(SP)	;EXECUTIVE
	MOV	#S.CCSM,R0	;SET BAD STACK ABORT CODE
	BR	85$		;ABORT CURRENT TASK

	.ENDC	;DF S$$LIB

	.DSABL	LSB

	.END